package writtenTraining.day4;

import java.util.*;

/**
 * day4:(1)模拟+贪心：WY22 Fibonacci数列
 */
public class Main {
    public static void main(String[] args) {
        // 输入
        Scanner in = new Scanner(System.in);
        long N = in.nextLong();

        long num1 = 0 , num2 = 1; 
        long ret = 0x3f3f3f3f;
        while(true) {
            long num3 = num1 + num2;
            if(Math.abs(N-num3) < ret) {
                ret = Math.abs(N-num3);
                num1 = num2;
                num2 = num3;
            } else {
                break;
            }
        } 

        // 输出
        System.out.println(ret);
    }
}


/**
 * day4:(2)深搜+回溯+剪枝：NC242 单词搜索
 */





class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param board string字符串一维数组
     * @param word string字符串
     * @return bool布尔型
     */
    //  定义全局的来存储
    int[] dx = {0,0,-1,1};
    int[] dy = {-1,1,0,0};
    int row , col, len;
    boolean[][] path;
    public boolean exist (String[] board, String word) {
        // 获取长度
        row = board.length;
        col = board[0].length();
        len = word.length();
        path = new boolean[row][col];

        // 搜索每一个起点
        for(int i = 0; i<row; i++) {
            for(int j = 0; j < col; j++) {
                if(board[i].charAt(j) == word.charAt(0)) {
                    path[i][j] = true;
                    // 让dfs 这个盒子来帮我们找，
                    // 如果找到了就直接返回true
                    if(dfs(board,word,i,j,1)) {
                        return true;
                    }

                    // 剪枝
                    path[i][j] = false;

                }
            }
        }

        return false;
    }
    private boolean dfs(String[] board, String word,int i, int j,int pos)   {
        // 递归出口
        if(pos == len) {
            // 如果到最后一个位置证明找到了
            return true;
        }

        // 进行深搜
        for(int k = 0; k < 4;k++) {
            int x = i + dx[k];
            int y = j + dy[k];
            // 剪枝
            if(x >= 0 && x < row &&
                    y >= 0 && y < col &&
                    board[x].charAt(y) == word.charAt(pos)
                    && !path[x][y]) {
                path[x][y] = true;
                boolean ret = dfs(board,word,x,y,pos+1);
                // 如果有结果就直接返回
                if(ret) {
                    return true;
                }
                // 回溯
                path[x][y] = false;
            }
        }

        return false;
    }
}


/**
 * day4:(3):动态规划+数字转化为字符串补空格：BC140 杨辉三角
 */




 class Main1 {
    public static void main(String[] args) {
        // 动态规划思想

        // 输入
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();

        // 创建dp
        int[][] dp = new int[n][n];
        // 初始化
        for(int i = 0; i < n ; i++) {
            dp[i][0] = 1;
        }

        // 填表
        for(int i = 1;i < n; i++) {
            for(int j = 1; j <= i; j++) {
                dp[i][j] = dp[i-1][j] + dp[i-1][j-1];
            }
        }

        // 输出结果
        for(int i = 0; i < n; i++) {

            for(int j = 0 ; j <= i; j++) {
                String ret  = "";
                // 获取长度就转化为字符串
                String num = Integer.toString(dp[i][j]);
                // 总共5个占位， 5 剪去数字的位置来循环补空格
                for(int k  = 0; k < 5-num.length();k++) {
                    ret += " ";
                }
                ret += num;
                System.out.print(ret);
            }
            System.out.println();
        }

    }
}